import * as XLSX from 'xlsx';
import * as ExcelJS from 'exceljs';
import { Buffer } from 'buffer';
import { Product, Category, Subcategory, ExcelData } from '../types';

/**
 * 产品图片映射表使用说明
 * 
 * 1. 如何添加真实产品图片：
 *    - 将产品图片转换为base64格式
 *    - 在PRODUCT_IMAGE_MAP中添加映射：'完整产品名称': 'data:image/jpeg;base64,实际图片数据'
 * 
 * 2. 支持的图片格式：
 *    - PNG: 
 *    - JPEG: 
 *    - SVG: 
 * 
 * 3. 图片转base64工具：
 *    - 在线工具：https://www.base64-image.de/
 *    - 或使用以下代码：
 *      const reader = new FileReader();
 *      reader.onload = () => console.log(reader.result);
 *      reader.readAsDataURL(file);
 * 
 * 4. 产品名称匹配：
 *    - 支持精确匹配和模糊匹配
 *    - 建议使用Excel中的完整产品名称作为key
 */

// 解析Excel文件
export const parseExcelFile = async (file: File): Promise<ExcelData[]> => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    
    reader.onload = (e) => {
      try {
        const data = e.target?.result;
        const workbook = XLSX.read(data, { type: 'binary' });
        
        const excelData: ExcelData[] = [];
        
        workbook.SheetNames.forEach(sheetName => {
          const worksheet = workbook.Sheets[sheetName];
          const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
          
          excelData.push({
            fileName: file.name,
            sheetName,
            data: jsonData as any[][],
          });
        });
        
        resolve(excelData);
      } catch (error) {
        reject(error);
      }
    };
    
    reader.onerror = () => reject(new Error('文件读取失败'));
    reader.readAsBinaryString(file);
  });
};

// 解析本地Excel文件（从URL加载）
// 注释掉，不再使用，避免重复加载
// export const parseExcelFileFromUrl = async (url: string, fileName: string): Promise<ExcelData[]> => {
//   return new Promise((resolve, reject) => {
//     fetch(url)
//       .then(response => {
//         if (!response.ok) {
//           throw new Error(`HTTP error! status: ${response.status}`);
//         }
//         return response.arrayBuffer();
//       })
//       .then(arrayBuffer => {
//         try {
//           const workbook = XLSX.read(arrayBuffer, { type: 'array' });
//           
//           const excelData: ExcelData[] = [];
//           
//           workbook.SheetNames.forEach(sheetName => {
//             const worksheet = workbook.Sheets[sheetName];
//             const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
//             
//             excelData.push({
//               fileName,
//               sheetName,
//               data: jsonData as any[][],
//             });
//           });
//           
//           resolve(excelData);
//         } catch (error) {
//           reject(error);
//         }
//       })
//       .catch(error => {
//         reject(new Error(`加载文件失败: ${error.message}`));
//       });
//   });
// };

// 解析本地Excel文件（从URL加载，带图片支持）
export const parseExcelFileFromUrlWithImages = async (url: string, fileName: string): Promise<ExcelData[]> => {
  return new Promise((resolve, reject) => {
    fetch(url)
      .then(response => {
        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }
        return response.arrayBuffer();
      })
      .then(async arrayBuffer => {
        try {
          const workbook = new ExcelJS.Workbook();
          await workbook.xlsx.load(arrayBuffer);
          
          const excelData: ExcelData[] = [];
          
          workbook.worksheets.forEach(worksheet => {
            const jsonData: any[][] = [];
            const imageData: { [key: string]: string } = {};
            
            // 提取图片
            if (worksheet.getImages && worksheet.getImages().length > 0) {
              console.log(`🖼️ 发现 ${worksheet.getImages().length} 个图片在工作表 ${worksheet.name}`);
              worksheet.getImages().forEach((image: any, imageIndex: number) => {
                try {
                  console.log(`📋 处理图片 ${imageIndex + 1}:`, image);
                  const img = workbook.getImage(image.imageId);
                  console.log(`📸 获取到图片对象:`, img);
                  
                  if (img && img.buffer) {
                    // 转换为base64
                    const base64 = Buffer.from(img.buffer).toString('base64');
                    const imgExtension = img.extension?.toLowerCase() || 'png';
                    const mimeType = imgExtension === 'png' ? 'image/png' : 
                                   (imgExtension === 'jpg' || imgExtension === 'jpeg') ? 'image/jpeg' : 
                                   imgExtension === 'gif' ? 'image/gif' :
                                   'image/' + imgExtension;
                    const dataUrl = `data:${mimeType};base64,${base64}`;
                    
                    // 使用图片位置作为key
                    const range = image.range;
                    const cellRef = `${range.tl.col}_${range.tl.row}`;
                    imageData[cellRef] = dataUrl;
                    
                    console.log(`✅ 图片处理完成:`);
                    console.log(`   - 位置: ${cellRef}`);
                    console.log(`   - 扩展名: ${imgExtension}`);
                    console.log(`   - MIME类型: ${mimeType}`);
                    console.log(`   - Base64长度: ${base64.length}`);
                    console.log(`   - DataURL前50字符: ${dataUrl.substring(0, 50)}...`);
                  } else {
                    console.warn(`⚠️ 图片 ${imageIndex + 1} 没有buffer数据:`, img);
                  }
                } catch (error) {
                  console.error(`❌ 图片 ${imageIndex + 1} 解析失败:`, error);
                }
              });
            }
            
            // 提取单元格数据
            worksheet.eachRow((row, rowNumber) => {
              const rowData: any[] = [];
              row.eachCell((cell, colNumber) => {
                // 检查是否有图片在这个位置
                const cellRef = `${colNumber - 1}_${rowNumber - 1}`;
                if (imageData[cellRef]) {
                  const cellImageObj = {
                    value: cell.value,
                    image: imageData[cellRef]
                  };
                  rowData[colNumber - 1] = cellImageObj;
                  console.log(`🔗 单元格 ${cellRef} 包含图片对象:`, cellImageObj);
                  console.log(`   - 单元格值: ${cell.value}`);
                  console.log(`   - 图片数据长度: ${imageData[cellRef].length}`);
                } else {
                  rowData[colNumber - 1] = cell.value;
                }
              });
              jsonData[rowNumber - 1] = rowData;
            });
            
            excelData.push({
              fileName,
              sheetName: worksheet.name,
              data: jsonData,
              images: imageData,
            });
          });
          
          resolve(excelData);
        } catch (error) {
          console.error('ExcelJS解析失败，回退到XLSX:', error);
          // 回退到原来的XLSX解析
          try {
            const workbook = XLSX.read(arrayBuffer, { type: 'array' });
            const excelData: ExcelData[] = [];
            
            workbook.SheetNames.forEach(sheetName => {
              const worksheet = workbook.Sheets[sheetName];
              const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
              
              excelData.push({
                fileName,
                sheetName,
                data: jsonData as any[][],
              });
            });
            
            resolve(excelData);
          } catch (xlsxError) {
            reject(xlsxError);
          }
        }
      })
      .catch(error => {
        reject(new Error(`加载文件失败: ${error.message}`));
      });
  });
};

// 从Excel数据转换为产品数据
export const convertExcelDataToProducts = (excelDataList: ExcelData[]): Category[] => {
  const categories: Category[] = [];
  

  
  excelDataList.forEach((excelData, sheetIndex) => {
    try {
      const { fileName, sheetName, data, images } = excelData;
      let imagesData:any[] = [] 
      if(images){
        Object.keys(images).map(item=>{
          imagesData.push(images[item])
        });
      }
      
      console.log(imagesData,'imagesData')
      console.log('图片数据:', images ? Object.keys(images) : '无图片数据');
      
      // 安全检查数据
      if (!data || !Array.isArray(data) || data.length < 2) {
        console.warn(`⚠️ 工作表 ${sheetName} 数据不足，跳过`);
        return; // 跳过这个工作表
      }
      
      // 智能检测Excel数据结构
      const structure = detectExcelStructure(data);
      if (structure.productNames.length === 0) {
        console.warn(`⚠️ 工作表 ${sheetName} 未检测到有效的产品名称`);
        return;
      }

      // 创建产品对象
      const products: Product[] = structure.productNames.map((productName: string, index: number) => {
        // 优先使用Excel中解析的图片数据
        let productImage = imagesData[index]
        
       

        console.log(index,'productImage',productImage)
        return {
          id: `${fileName}-${sheetName}-${productName}-${index}`,
          name: productName,
          category: fileName.replace(/\.(xlsx|xls)$/i, ''),
          subcategory: sheetName,
          specs: {},
          image: productImage || undefined, // 将null转换为undefined
        };
      });

      // 根据检测到的结构处理数据
      if (structure.isTransposed) {
        // 纵向布局：第一列是产品名，第一行是参数名
        console.log(`📊 处理纵向布局数据`);
        for (let colIndex = structure.startCol; colIndex < (data[0]?.length || 0); colIndex++) {
          try {
            const paramName = String(data[0]?.[colIndex] || '').trim();
            if (!paramName) continue;

            console.log(`🔄 处理参数 "${paramName}"`);

            for (let rowIndex = structure.startRow; rowIndex < data.length; rowIndex++) {
              try {
                const productName = String(data[rowIndex]?.[0] || '').trim();
                const productIndex = structure.productNames.indexOf(productName);
                
                if (productIndex !== -1) {
                  const paramValue = data[rowIndex]?.[colIndex];
                  if (paramValue !== undefined && paramValue !== null && paramValue !== '') {
                    console.log(`🔄 处理产品 "${productName}" 的参数 "${paramName}":`, typeof paramValue, paramValue);
                    
                    // 所有参数都直接转换为文本（不再处理Excel中的图片对象）
                    products[productIndex].specs[paramName] = String(paramValue);
                  }
                }
              } catch (cellError) {
                console.warn(`⚠️ 处理单元格 [${rowIndex}, ${colIndex}] 时出错:`, cellError);
              }
            }
          } catch (paramError) {
            console.warn(`⚠️ 处理参数列 ${colIndex} 时出错:`, paramError);
          }
        }
      } else {
        // 横向布局：第一行是产品名，第一列是参数名
        console.log(`📊 处理横向布局数据`);
        for (let rowIndex = structure.startRow; rowIndex < data.length; rowIndex++) {
          try {
            const paramName = String(data[rowIndex]?.[0] || '').trim();
            if (!paramName) continue;

            console.log(`🔄 处理参数 "${paramName}"`);

            structure.productNames.forEach((productName: string, productIndex: number) => {
              try {
                const paramValue = data[rowIndex]?.[productIndex + structure.startCol];
                if (paramValue !== undefined && paramValue !== null && paramValue !== '') {
                  console.log(`🔄 处理产品 "${productName}" 的参数 "${paramName}":`, typeof paramValue, paramValue);
                  
                  // 所有参数都直接转换为文本（不再处理Excel中的图片对象）
                  products[productIndex].specs[paramName] = String(paramValue);
                }
              } catch (productError) {
                console.warn(`⚠️ 处理产品 "${productName}" 的参数 "${paramName}" 时出错:`, productError);
              }
            });
          } catch (rowError) {
            console.warn(`⚠️ 处理参数行 ${rowIndex} 时出错:`, rowError);
          }
        }
      }
      
      // 过滤掉没有任何参数的产品
      const validProducts = products.filter(product => Object.keys(product.specs).length > 0);
      if (validProducts.length === 0) return;
      
      // 查找或创建分类
      const categoryName = fileName.replace(/\.(xlsx|xls)$/i, '');
      let category = categories.find(c => c.name === categoryName);
      if (!category) {
        category = {
          id: categoryName,
          name: categoryName,
          subcategories: [],
        };
        categories.push(category);
      }
      
      // 查找或创建子分类
      let subcategory = category.subcategories.find(s => s.name === sheetName);
      if (!subcategory) {
        subcategory = {
          id: `${category.id}-${sheetName}`,
          name: sheetName,
          products: [],
        };
        category.subcategories.push(subcategory);
      }
      
      // 添加产品到子分类
      subcategory.products = validProducts;
    } catch (sheetError) {
      console.error(`❌ 处理工作表 ${sheetIndex + 1} 时出错:`, sheetError);
    }
  });
  
  return categories;
};

// 加载本地Excel文件
export const loadLocalExcelFiles = async (): Promise<Category[]> => {
  try {
    console.log('🚀 开始加载本地Excel文件...');
    
    // 定义要加载的Excel文件列表 - 只加载EC產品系列對比圖 (1).xlsx
    const excelFiles = [
      'EC產品系列對比圖 (1).xlsx',
      'FC對比圖.xlsx'
    ];
    
    console.log(`📋 准备加载 ${excelFiles.length} 个Excel文件:`, excelFiles);
    
    const allExcelData: ExcelData[] = [];
    
    // 并行加载所有Excel文件 - 使用带图片支持的解析
    const loadPromises = excelFiles.map(async (fileName) => {
      try {
        const url = `/excel/${encodeURIComponent(fileName)}`;
        console.log(`📂 正在加载文件: ${fileName} (URL: ${url})`);
        
        // 使用带图片支持的解析函数
        const excelData = await parseExcelFileFromUrlWithImages(url, fileName);
        
        console.log(`excelData`,excelData);
        return excelData;
      } catch (error) {
        console.warn(`❌ 文件 ${fileName} 加载失败:`, error);
        return [];
      }
    });
    
    const results = await Promise.all(loadPromises);
    
    // 合并所有Excel数据
    results.forEach(excelDataList => {
      allExcelData.push(...excelDataList);
    });
    
    if (allExcelData.length === 0) {
      console.warn('⚠️ 没有找到预设的Excel文件，返回空的分类列表');
      return [];
    }
    
    console.log(`📊 成功加载 ${allExcelData.length} 个工作表数据`);
    
    // 转换为产品数据
    const categories = convertExcelDataToProducts(allExcelData);
    
    console.log(`🎯 转换完成，共 ${categories.length} 个分类:`);
    categories.forEach(category => {
      console.log(`  - ${category.name}: ${category.subcategories.length} 个子分类`);
      category.subcategories.forEach(sub => {
        console.log(`    - ${sub.name}: ${sub.products.length} 个产品`);
      });
    });
    
    return categories;
  } catch (error) {
    console.error('💥 加载Excel文件失败:', error);
    // 返回空数组而不是抛出错误
    return [];
  }
};

// 解析Excel文件（带图片支持）
export const parseExcelFileWithImages = async (file: File): Promise<ExcelData[]> => {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    
    reader.onload = async (e) => {
      try {
        const data = e.target?.result as ArrayBuffer;
        const workbook = new ExcelJS.Workbook();
        await workbook.xlsx.load(data);
        
        const excelData: ExcelData[] = [];
        
        workbook.worksheets.forEach((worksheet,sheetIndex) => {
          const jsonData: any[][] = [];
          const imageData: { [key: string]: string } = {};
          
          console.log(worksheet,'worksheet')
          // 提取图片
          if (worksheet.getImages && worksheet.getImages().length > 0) {
            worksheet.getImages().forEach((image: any,imageIndex:number) => {
              try {
                const img = workbook.getImage(image.imageId);
                if (img && img.buffer) {
                  // 转换为base64
                  const base64 = Buffer.from(img.buffer).toString('base64');
                  const imgExtension = img.extension?.toLowerCase() || 'png';
                  const mimeType = imgExtension === 'png' ? 'image/png' : 
                                 (imgExtension === 'jpg' || imgExtension === 'jpeg') ? 'image/jpeg' : 
                                 imgExtension === 'gif' ? 'image/gif' :
                                 'image/' + imgExtension;
                  const dataUrl = `data:${mimeType};base64,${base64}`;
                  
                  // 使用图片位置作为key
                  imageData[sheetIndex+'_'+imageIndex] = dataUrl;
                }
              } catch (error) {
                console.warn('图片解析失败:', error);
              }
            });
          }
          
          // 提取单元格数据
          worksheet.eachRow((row, rowNumber) => {
            const rowData: any[] = [];
            row.eachCell((cell, colNumber) => {
              // 检查是否有图片在这个位置
              const cellRef = `${colNumber - 1}_${rowNumber - 1}`;
              if (imageData[cellRef]) {
                rowData[colNumber - 1] = {
                  value: cell.value,
                  image: imageData[cellRef]
                };
              } else {
                rowData[colNumber - 1] = cell.value;
              }
            });
            jsonData[rowNumber - 1] = rowData;
          });
          
          console.log(imageData,'imageData')
          excelData.push({
            fileName: file.name,
            sheetName: worksheet.name,
            data: jsonData,
            images: imageData,
          });
        });
        
        resolve(excelData);
      } catch (error) {
        console.error('ExcelJS解析失败，回退到XLSX:', error);
        // 回退到原来的XLSX解析
        try {
          const arrayBuffer = e.target?.result as ArrayBuffer;
          const workbook = XLSX.read(arrayBuffer, { type: 'array' });
          const excelData: ExcelData[] = [];
          
          workbook.SheetNames.forEach(sheetName => {
            const worksheet = workbook.Sheets[sheetName];
            const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
            
            excelData.push({
              fileName: file.name,
              sheetName,
              data: jsonData as any[][],
            });
          });
          
          resolve(excelData);
        } catch (xlsxError) {
          reject(xlsxError);
        }
      }
    };
    
    reader.onerror = () => reject(new Error('文件读取失败'));
    reader.readAsArrayBuffer(file);
  });
};

// 智能检测Excel数据结构
const detectExcelStructure = (data: any[][]): { 
  isTransposed: boolean; 
  productNames: string[]; 
  paramNames: string[];
  startRow: number;
  startCol: number;
} => {
  if (!data || data.length < 2) {
    return { isTransposed: false, productNames: [], paramNames: [], startRow: 0, startCol: 0 };
  }

  console.log(`🔍 检测Excel结构，数据行数: ${data.length}`);
  
  // 安全地获取第一行数据
  const firstRow = data[0] || [];
  
  console.log(`🔍 第一行数据:`, firstRow);

  // 强制使用标准结构: 第一列是参数名，第一行（除第一个单元格）是产品名称
  // 第一行从第二列开始是产品名称
  const productNames = firstRow.slice(1).filter(cell => {
    try {
      return cell && 
        typeof cell !== 'object' && // 排除对象
        String(cell).trim() && 
        String(cell).trim() !== '' &&
        String(cell).trim() !== 'undefined' &&
        String(cell).trim() !== 'null';
    } catch (e) {
      console.warn('处理产品名称单元格时出错:', cell, e);
      return false;
    }
  }).map(name => String(name).trim());
  
  // 第一列从第二行开始是参数名称
  const paramNames = data.slice(1).map(row => {
    try {
      return row && row[0] ? row[0] : null;
    } catch (e) {
      console.warn('读取参数名称行数据时出错:', row, e);
      return null;
    }
  }).filter(cell => {
    try {
      return cell && 
        typeof cell !== 'object' && // 排除对象
        String(cell).trim() && 
        String(cell).trim() !== '' &&
        String(cell).trim() !== 'undefined' &&
        String(cell).trim() !== 'null';
    } catch (e) {
      console.warn('处理参数名称单元格时出错:', cell, e);
      return false;
    }
  }).map(name => String(name).trim());

  console.log(`📊 标准结构解析: 产品数=${productNames.length}, 参数数=${paramNames.length}`);
  console.log(`📊 产品名称:`, productNames);
  console.log(`📊 参数名称:`, paramNames.slice(0, 5), '...(只显示前5个)');

  // 使用标准的横向布局: 第一行是产品名，第一列是参数名
  console.log(`✅ 使用标准结构: 第一列是参数名，第一行是产品名称`);
  return {
    isTransposed: false, // 横向布局
    productNames: productNames,
    paramNames: paramNames,
    startRow: 1, // 从第二行开始是数据
    startCol: 1  // 从第二列开始是数据
  };
}; 